{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 介绍\n",
    "python是一种非常简单易学的解释性语言。由于强大的开源库支持(numpy,scipy,matplotlib)，其广泛应用于科学计算中。如果你励志成为一名数据科学家或数据“攻城狮”，那python就是你必须学会的工具之一。接下来我们将简短的介绍下python, numpy, matplotlib的使用。本章教程内容主要参考于斯坦福大学cs228课程的python教程，详情可使用该网址查看 https://github.com/kuleshov/cs228-material/blob/master/tutorials/python/cs228-python-tutorial.ipynb "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在本章中，你将逐步学习以下内容：\n",
    "* Python基本使用: 基本数据类型(Containers, Lists, Dictionaries, Sets, Tuples), 函数, 类\n",
    "* Numpy: 数组, 数组索引, 数据类型,数组运算, 广播\n",
    "* Matplotlib: Plotting, Subplots, Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python基本用法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python是一种面向对象的解释型高级编程语言。很多时候，由于其代码具有高可读性，且只需要数行代码就可以表达复杂的功能，Python看起来简直和伪代码一样。如下所示，为Python实现经典的快速排序算法例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 3, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "def quicksort(arr):\n",
    "    if len(arr) <= 1:\n",
    "        return arr\n",
    "    pivot = arr[int(len(arr) / 2)]\n",
    "    left = [x for x in arr if x < pivot]\n",
    "    middle = [x for x in arr if x == pivot]\n",
    "    right = [x for x in arr if x > pivot]\n",
    "    return quicksort(left) + middle + quicksort(right)\n",
    "\n",
    "print(quicksort([3,6,8,10,1,2,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python 版本"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python有两个差异较大的版本，分别是2.7+和3.4+。由于在3.0版本和2.7版本语言不兼容，因此2.7下的代码有时候在3.4下是行不通的。本教程中，我们使用的是3.8版本。你可以使用python --version命令。查看你所下载的python版本，确保你的python版本符合我们的教程需求。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 基本数据类型\n",
    "和大多数编程语言一样，Python拥有一系列的基本数据类型，比如整型、浮点型、布尔型和字符串等。这些基本数据类型的使用方式和其他语言的使用方式类似。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 整型和浮点型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "2\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "print(x + 1)   # 加;\n",
    "print(x - 1)   # 减;\n",
    "print(x * 2)   # 乘;\n",
    "print(x ** 2)  # 幂乘;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "x += 1\n",
    "print(x)  # 打印 \"4\"\n",
    "x *= 2\n",
    "print(x)  # 打印 \"8\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "2.5 3.5 5.0 6.25\n"
     ]
    }
   ],
   "source": [
    "y = 2.5\n",
    "print(type(y)) # 打印 \"<type 'float'>\"\n",
    "print(y, y + 1, y * 2, y ** 2) # 打印 \"2.5 3.5 5.0 6.25\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (Temp/ipykernel_11896/3264599002.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"C:\\Users\\23820\\AppData\\Local\\Temp/ipykernel_11896/3264599002.py\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    print(y++)\u001b[0m\n\u001b[1;37m             ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "#python不支持(x++) 或(x--) 运算.\n",
    "print(y++)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 布尔型\n",
    "Python实现了所有的布尔逻辑，但使用的是英语单词(\"and\",\"or\",\"not\")等，而不是我们习惯的操作符（\"&&\",\"||\"等）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "t, f = True, False\n",
    "print(type(t)) # 打印 \"<type 'bool'>\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "逻辑运算:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(t and f) # 逻辑 AND;\n",
    "print(t or f)  # 逻辑 OR;\n",
    "print(not t)  # 逻辑 NOT;\n",
    "print(t != f)  # 逻辑 XOR;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello 5 world\n"
     ]
    }
   ],
   "source": [
    "hello = 'hello'   # 字符串可以使用单引号\n",
    "world = \"world\"   # 也可以使用双引号\n",
    "print(hello, len(hello),world)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "hw = hello + ' ' + world  # 字符串拼接\n",
    "print(hw)  # 打印 \"hello world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world 12\n"
     ]
    }
   ],
   "source": [
    "hw12 = '%s %s %d' %(hello, world, 12)  # 按格式输出\n",
    "print(hw12)  # 打印 \"hello world 12\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你也可以将字符串当作是一个对象，其有大量的方法。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "HELLO\n",
      "  hello\n",
      " hello \n",
      "he(ell)(ell)o\n",
      "wo  rld\n"
     ]
    }
   ],
   "source": [
    "s = \"hello\"\n",
    "print(s.capitalize())  # 将字符串首字母大写; 打印 \"Hello\"\n",
    "print(s.upper())       # 将字符串转换成大写; 打印 \"HELLO\"\n",
    "print(s.rjust(7))      # 字符串向右对齐, 使用空格进行站位; 打印 \"  hello\"\n",
    "print(s.center(7))     # 字符串居中, 使用空格对左右进行站位; 打印 \" hello \"\n",
    "print(s.replace('l', '(ell)'))  # 使用子串代替规定处字符\n",
    "                               # 打印 \"he(ell)(ell)o\"\n",
    "print('   wo  rld '.strip())  # 删除空白字符（开头或结尾）; 打印 \"wor  ld\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更多字符串操作请参考以下网址(https://docs.python.org/2/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 容器\n",
    "Python有以下几种容器类型：列表（lists）、字典（dictionaries）、集合（sets）和元组（tuples）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 列表(Lists)\n",
    "在Python中，列表相当于数组，但是列表长度可变，且能包含不同类型元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 2] 2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "xs = [3, 1, 2]   # 创建列表\n",
    "print(xs, xs[2])\n",
    "print(xs[-1])     #负值索引相当于从列表的末端进行反向索引; 打印 \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "xs[2] = 'foo'    # 列表可以包含不同的元素\n",
    "print(xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 'foo', 'bar']\n"
     ]
    }
   ],
   "source": [
    "xs.append('bar') # 添加新元素到列表末端\n",
    "print(xs) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bar [3, 1, 'foo']\n"
     ]
    }
   ],
   "source": [
    "x = xs.pop()     # 移除列表末端元素\n",
    "print(x, xs) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更多列表操作请参考以下网址(https://docs.python.org/2/tutorial/datastructures.html#more-on-lists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 切片(Slicing)\n",
    "\n",
    "为了同时获取列表中的多个元素，Python提供了一种简洁的语法去访问子列表，这就是切片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[2, 3, 4]\n",
      "[0, 1]\n",
      "[0, 1, 2, 3, 4]\n",
      "[0, 1, 2, 3]\n",
      "[0, 1, 's', 'we', 4]\n"
     ]
    }
   ],
   "source": [
    "nums = list(range(5))    # range是内置的创建整型列表函数\n",
    "print(nums)         # 打印 \"[0, 1, 2, 3, 4]\"\n",
    "print(nums[2:4])    # 获取索引2-4(排除)的子列表; 打印 \"[2, 3]\"\n",
    "print(nums[2:])     # 获取索引2到末的子列表; 打印 \"[2, 3, 4]\"\n",
    "print(nums[:2])    # 获取索引开始到2(排除)的子列表; 打印 \"[0, 1]\"\n",
    "print(nums[:])     # 获取整个列表; 打印 [\"0, 1, 2, 3, 4]\"\n",
    "print(nums[:-1])   # 切片也可以使用负号索引; 打印 [\"0, 1, 2, 3]\"\n",
    "nums[2:4] = ['s','we'] # 用新子列表替换指定索引列表中的子列表\n",
    "print(nums)         # 打印 \"[0, 1, s, we, 4]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 循环(Loops)\n",
    "我们可以这样遍历列表中的每一个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat\n",
      "dog\n",
      "monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for animal in animals:\n",
    "    print(animal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果想要在循环体内访问每个元素的指针，可以使用内置的枚举(enumerate)函数。注意：起始号0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: cat\n",
      "#2: dog\n",
      "#3: monkey\n"
     ]
    }
   ],
   "source": [
    "animals = ['cat', 'dog', 'monkey']\n",
    "for idx, animal in enumerate(animals):\n",
    "    print('#%d: %s' %(idx + 1, animal))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 列表解析(List comprehensions):\n",
    "\n",
    "在编程的时候，我们常常想要将列表中的每一元素使用特定的表达式进行转换。下面是一个简单例子，将列表中的每个元素转换成它的平方。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "squares = []\n",
    "for x in nums:\n",
    "    squares.append(x ** 2)\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你可以使用更简单的列表解析(list comprehension):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "squares = [x ** 2 for x in nums]\n",
    "print(squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "列表解析也可以包含条件语句:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "even_squares = [x ** 2 for x in nums if x % 2 == 0]\n",
    "print(even_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 字典（Dictionaries）\n",
    "\n",
    "字典用来储存（键, 值）对，这和Java中的Map差不多。你可以这样使用它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cute\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "d = {'cat': 'cute', 'dog': 'furry'}  # 为数据创建字典\n",
    "print(d['cat'])       # 从字典中获取词条(entry); 打印 \"cute\"\n",
    "print('cat' in d)     # 检查字典中是否有给定键值(key); 打印 \"True\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wet\n"
     ]
    }
   ],
   "source": [
    "d['fish'] = 'wet'    # 给定键值，创建词条\n",
    "print(d['fish'])      # 打印 \"wet\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'monkey'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_11896/3201959582.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0md\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'monkey'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# KeyError: 'monkey' 键值没有在字典中\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'monkey'"
     ]
    }
   ],
   "source": [
    "print(d['monkey'])  # KeyError: 'monkey' 键值没有在字典中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n",
      "wet\n"
     ]
    }
   ],
   "source": [
    "print(d.get('monkey', 'N/A'))  # 获取字典中元素默认值; 打印 \"N/A\"\n",
    "print(d.get('fish', 'N/A'))    # 获取字典中元素默认值; 打印 \"wet\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N/A\n"
     ]
    }
   ],
   "source": [
    "del d['fish']        # 从字典中移除元素\n",
    "print(d.get('fish', 'N/A')) # \"fish\" 不在是字典中的键值; 打印 \"N/A\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典的详细用法请参考以下网址：(https://docs.python.org/2/library/stdtypes.html#dict)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "迭代字典:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 人 有 2 腿\n",
      " 猫 有 4 腿\n",
      " 蜘蛛 有 8 腿\n"
     ]
    }
   ],
   "source": [
    "d = {'人': 2, '猫': 4, '蜘蛛': 8}\n",
    "for animal in d:\n",
    "    legs = d[animal]\n",
    "    print(' %s 有 %d 腿' %(animal, legs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你也可以使用iteritems方法进行迭代:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 人 有 2 腿\n",
      " 猫 有 4 腿\n",
      " 蜘蛛 有 8 腿\n"
     ]
    }
   ],
   "source": [
    "d = {'人': 2, '猫': 4, '蜘蛛': 8}\n",
    "for animal, legs in d.items():\n",
    "    print(' %s 有 %d 腿' %(animal, legs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典解析(Dictionary comprehensions): 和列表解析类似,字典解析允许你轻松的构造字典，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 2: 4, 4: 16}\n"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4]\n",
    "even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}\n",
    "print(even_num_to_square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 集合(Sets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "集合存放着无序的不同元素，在python中，集合使用花括号表示，如果将一个序列转换为集合，那该序列的重复元素将会被剔除，并且原有的顺序也将被打散。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog'}\n",
    "print('cat' in animals)   # 检查是否元素在集合中; 打印 \"True\"\n",
    "print('fish' in animals)  # 打印 \"False\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "animals.add('fish')      # 向集合中添加元素\n",
    "print('fish' in animals)\n",
    "print(len(animals) )      # 集合中的元素个数;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "animals.add('cat')       # 添加一个存在的元素进集合中，其没有变化。\n",
    "print(len(animals) )      \n",
    "animals.remove('cat')    # 从集合中移除一个元素\n",
    "print(len(animals) )      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "集合循环：虽然集合中的循环语法和列表中的一样，但由于集合是无序的，因此访问集合元素的时候，不能做关于顺序的假设："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: dog\n",
      "#2: fish\n",
      "#3: cat\n"
     ]
    }
   ],
   "source": [
    "animals = {'cat', 'dog', 'fish'}\n",
    "for idx, animal in enumerate(animals):\n",
    "    print('#%d: %s' %(idx + 1, animal))\n",
    "# 打印 \"#1: fish\", \"#2: dog\", \"#3: cat\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "集合解析(Set comprehensions)：和字典，列表一样，你可以很方便地使用集合解析构建集合："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "print({int(sqrt(x)) for x in range(30)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 元组(Tuples)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元组是一个（不可改变）有序列表。元组和列表在很多方面都很相似，最大的不同在于，元组可以像字典一样使用键/值对，并且还可以作为集合的元素，而列表不行。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "d = {(x, x + 1): x for x in range(10)}  # 通过元组键值创建字典\n",
    "t =(5, 6)       # 创建元组 \n",
    "print(type(t))\n",
    "print(d[t])      \n",
    "print(d[(1, 2)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_11896/2642684736.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m1\u001b[0m \u001b[1;31m# TypeError: 'tuple' object does not support item assignment\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0] = 1 # TypeError: 'tuple' object does not support item assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "Python使用关键词`def`来定义函数，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "负\n",
      "零\n",
      "正\n"
     ]
    }
   ],
   "source": [
    "def sign(x):\n",
    "    if x > 0:\n",
    "        return '正'\n",
    "    elif x < 0:\n",
    "        return '负'\n",
    "    else:\n",
    "        return '零'\n",
    "\n",
    "for x in [-1, 0, 1]:\n",
    "    print(sign(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们也经常使用可选参数来定义函数，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Bob!\n",
      "HELLO, FRED\n"
     ]
    }
   ],
   "source": [
    "def hello(name, loud=False):\n",
    "    if loud:\n",
    "        print('HELLO, %s' % name.upper())\n",
    "    else:\n",
    "        print('Hello, %s!' % name)\n",
    "\n",
    "hello('Bob')\n",
    "hello('Fred', loud=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 类(Classes)\n",
    "在python中，定义类的语法很直接："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Fred\n",
      "HELLO, FRED!\n"
     ]
    }
   ],
   "source": [
    "class Greeter:\n",
    "\n",
    "    # 构造函数\n",
    "    def __init__(self, name):\n",
    "        self.name = name  # 创建一个变量实例\n",
    "\n",
    "    # 实例方法 \n",
    "    def greet(self, loud=False):\n",
    "        if loud:\n",
    "            print('HELLO, %s!' % self.name.upper())\n",
    "        else:\n",
    "            print('Hello, %s' % self.name)\n",
    "\n",
    "g = Greeter('Fred')  # 创建一个Greeter类实例 \n",
    "g.greet()            # 调用实例方法; 打印 \"Hello, Fred\"\n",
    "g.greet(loud=True)   # 调用实例方法; 打印 \"HELLO, FRED!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "Numpy是Python中用于科学计算的核心库。其提供了高性能的多维数组对象，以及相关工具。其用法和MATLAB相似，详情请参考如下网址：(http://wiki.scipy.org/NumPy_for_Matlab_Users)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "要使用Numpy，首先要导入`numpy`包："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组(Arrays)\n",
    "numpy数组是由相同数据类型组成的网格，其可以通过非负整型的元组访问。数组维度数量也被称为数组的秩或阶(rank)，数组的形状是一个由整型数构成的元组，描述数组不同维度上的大小。我们可以从python内嵌的列表中创建数组，然后利用方括号访问其中的元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> (3,) 1 2 3\n",
      "[5 2 3]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])  # 创建秩为1的数组\n",
    "print(type(a), a.shape, a[0], a[1], a[2])\n",
    "a[0] = 5                 # 改变数组元素\n",
    "print(a)                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[1,2,3],[4,5,6]])   # 创建秩为2的数组\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "1 2 4\n"
     ]
    }
   ],
   "source": [
    "print(b.shape)   # 查看b的维度                \n",
    "print(b[0, 0], b[0, 1], b[1, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy同样提供了大量的方法创建数组:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.zeros((2,2))  # 创建2*2的零矩阵\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "b = np.ones((1,2))   # 创建各元素值为1的1*2矩阵\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 7]\n",
      " [7 7]]\n"
     ]
    }
   ],
   "source": [
    "c = np.full((2,2), 7,) # 创建各元素值为7的2*2矩阵\n",
    "print(c) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "d = np.eye(3)        # 创建3*3的单位矩阵\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.9626719  0.66113208 0.71213143]\n",
      " [0.04312188 0.54593384 0.61953381]\n",
      " [0.03517364 0.11899646 0.29335206]]\n"
     ]
    }
   ],
   "source": [
    "e = np.random.random((3,3)) # 创建3*3的矩阵，使用随机数填充值\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组索引\n",
    "切片：和Python列表类似，numpy数组可以使用切片语法。因为数组可以是多维的，所以你必须为每个维度指定好切片："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "[[2 3]\n",
      " [6 7]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "# 创建秩为2，形状为（3,4）的数组\n",
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "print(a)\n",
    "#取出第1行，2列开始的，形状为（2,2）的子数组\n",
    "# [[2 3]\n",
    "#  [6 7]]\n",
    "b = a[:2, 1:3]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "切取的子数组实际上是原数组的一份浅备份，因此修改子数组，原始数组也将受到修改，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "原始a: 2\n",
      "修改b后的a： 77\n"
     ]
    }
   ],
   "source": [
    "print('原始a:',a[0, 1]  )\n",
    "b[0, 0] = 77    # b[0, 0] 和a[0, 1]共享同一内存\n",
    "print('修改b后的a：',a[0, 1] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你也可以混合整数索引以及切片索引访问数组，但是，这会生成一个秩少于原始数组的子数组。注意：这和MATLAB处理的数组切片有些不同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "# 创建形状（3,4）秩为2的numpy数组\n",
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy有两种数组切片方式：1.混合整数索引和切片，生成低秩子数组；2.仅使用切片，生成原始数组同秩的子数组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "秩为1： [5 6 7 8] (4,)\n",
      "秩为2： [[5 6 7 8]] (1, 4)\n",
      "秩为2： [[5 6 7 8]] (1, 4)\n"
     ]
    }
   ],
   "source": [
    "row_r1 = a[1, :]    # 秩为1，数组a的第二行子数组 \n",
    "row_r2 = a[1:2, :]  # 秩为2，数组a的第二行子数组 \n",
    "row_r3 = a[[1], :]  # 秩为2，数组a的第二行子数组\n",
    "print('秩为1：',row_r1, row_r1.shape )\n",
    "print('秩为2：',row_r2, row_r2.shape)\n",
    "print('秩为2：',row_r3, row_r3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "秩为1： [ 2  6 10] (3,)\n",
      "秩为2：\n",
      "[[ 2]\n",
      " [ 6]\n",
      " [10]] (3, 1)\n"
     ]
    }
   ],
   "source": [
    "# 作用在列上同样适用:\n",
    "col_r1 = a[:, 1] # 秩为1，数组a的第二列子数组\n",
    "col_r2 = a[:, 1:2] # 秩为2，数组a的第二列子数组\n",
    "print('秩为1：',col_r1, col_r1.shape)\n",
    "print('秩为2：')\n",
    "print(col_r2, col_r2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "整型数组索引：当我们使用切片索引数组时，得到的总是原数组的子数组。整型数组索引允许我们利用其它数组中的数据构建一个新的数组。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5]\n",
      "[1 4 5]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "# 整型数组索引示例。\n",
    "# 返回的数组形状为(3,)\n",
    "print(a[[0, 1, 2], [0, 1, 0]])\n",
    "\n",
    "# 上述整型数组索引相等于下列索引:\n",
    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2]\n",
      "[2 2]\n"
     ]
    }
   ],
   "source": [
    "#当使用整型数组索引时，你可以重复索引同一个数组元素：\n",
    "print(a[[0, 0], [1, 1]])\n",
    "\n",
    "# 上述整型数组索引相等于下列索引：\n",
    "print(np.array([a[0, 1], a[0, 1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "整型数组索引的一个小技巧是从矩阵的每一行中选择或改变元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "使用数组[0, 2, 0, 1]索引矩阵a中的每一行\n",
      "[ 1  6  7 11]\n",
      "使用数组[0, 2, 0, 1]索引矩阵a中的每一行，将其加10\n",
      "[[11  2  3]\n",
      " [ 4  5 16]\n",
      " [17  8  9]\n",
      " [10 21 12]]\n"
     ]
    }
   ],
   "source": [
    "# 创建新数组用于选择元素\n",
    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print(a)\n",
    "# 创建数组索引。\n",
    "b = np.array([0, 2, 0, 1])\n",
    "print('使用数组[0, 2, 0, 1]索引矩阵a中的每一行')\n",
    "# 使用数组b中的索引选择矩阵a每一行中的特定元素。\n",
    "print(a[np.arange(4), b])  # 打印 \"[ 1  6  7 11]\"\n",
    "\n",
    "#使用数组b中的索引改变矩阵a每一行中的特定元素。\n",
    "print('使用数组[0, 2, 0, 1]索引矩阵a中的每一行，将其加10')\n",
    "a[np.arange(4), b] += 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "布尔型数组索引：布尔型索引让你任意挑选数组中的元素，这种类型索引频繁的用于条件语句下的元素选取。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 1]]\n",
      "[[False False]\n",
      " [ True  True]\n",
      " [ True False]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.array([[1,2], [3, 4], [5, 1]])\n",
    "print(a)\n",
    "bool_idx =(a > 2)  \n",
    "# 寻找大于2的数组元素，返回相同形状的布尔型数组，其每个元素为a > 2的布尔值\n",
    "print(bool_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 5]\n",
      "[3 4 5]\n"
     ]
    }
   ],
   "source": [
    "# 我们可以使用布尔数组索引去构造一个秩为1的数组，其元素与布尔数组的真值相对应。\n",
    "print(a[bool_idx])\n",
    "\n",
    "# 我们也可以将上述内容简洁的用一行语句表达：\n",
    "print(a[a > 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数据类型(Datatypes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy提供了大量的数据类型去构造数组，Numpy会尝试猜测你创建的数组的数据类型，但构造函数的数组通常也会可选择的显式指明其数据类型。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32 float64 int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2])  # 让numpy自己选择数据类型\n",
    "y = np.array([1.0, 2.0])  # 让numpy自己选择数据类型\n",
    "z = np.array([1, 2], dtype=np.int64)  # 显式的规定数据类型\n",
    "\n",
    "print(x.dtype, y.dtype, z.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "详细的数据类型说明，可参考如下网址：(http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数组数学运算 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数组中基本的数学运算操作是按数组元素进行的，并且重载操作以及函数都可以使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "# 按元素求和；两种方式都可以使用；\n",
    "print(x + y)\n",
    "print(np.add(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n"
     ]
    }
   ],
   "source": [
    "# 按元素相减；\n",
    "print(x - y)\n",
    "print(np.subtract(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n"
     ]
    }
   ],
   "source": [
    "# 按元素乘；\n",
    "print(x * y)\n",
    "print(np.multiply(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n"
     ]
    }
   ],
   "source": [
    "# 按元素除\n",
    "# [[ 0.2         0.33333333]\n",
    "#  [ 0.42857143  0.5       ]]\n",
    "print(x / y)\n",
    "print(np.divide(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "# 按元素取平方根；\n",
    "# [[ 1.          1.41421356]\n",
    "#  [ 1.73205081  2.        ]]\n",
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：和MATLAB不同，`*`在numpy中是按元素乘，而在MATLAB中是矩阵乘。在numpy中我们使用dot函数计算向量内积(点积)，矩阵乘矩阵，以及矩阵乘向量等操作。dot可以当作函数在numpy中使用，也可作为数组对象的实例方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n",
      "219\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "\n",
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "# 向量内积；都将生成219\n",
    "print(v.dot(w))\n",
    "print(np.dot(v, w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[29 67]\n",
      "[29 67]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵 / 向量乘积; 都将生成秩为1的数组[29 67]。\n",
    "print(x.dot(v))\n",
    "print(np.dot(x, v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵 / 矩阵乘积;都将生成秩为2的数组\n",
    "# [[19 22]\n",
    "#  [43 50]]\n",
    "print(x.dot(y))\n",
    "print(np.dot(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy还提供了许多有用的数组计算函数；其中最常用的是 `sum` 函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "[4 6]\n",
      "[3 7]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "\n",
    "print(np.sum(x))  # 计算所有元素的累加和；打印 \"10\"\n",
    "print(np.sum(x, axis=0))  # 计算每一列的累加和；打印\"[4 6]\"\n",
    "print(np.sum(x, axis=1))  # 计算每一行的累加和；打印\"[3 7]\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更多numpy的数学函数参见如下网址：(http://docs.scipy.org/doc/numpy/reference/routines.math.html).\n",
    "\n",
    "除了使用数组进行数学计算，我们还频繁的使用reshape或者其他方法操纵数组数据。例如：要转置一个矩阵，简单的使用数组对象的T属性即可："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(x.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]]\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([[1,2,3]])\n",
    "print(v) \n",
    "print(v.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 广播(Broadcasting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "广播提供了强大的机制允许numpy在不同形状的数组中执行数学操作。我们经常会遇到小数组和大数组相乘的情况，比如图片数据矩阵与权重矩阵。使用广播机制将提高你的代码质量以及运算效率。\n",
    "\n",
    "例如，假设我们想在矩阵的每一行中都加上一个常数向量。我们可以这样做："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵x的每一行加上向量v，将结果储存在矩阵y中。\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = np.empty_like(x)   # 创建一个和x形状相同的空矩阵。\n",
    "\n",
    "# 使用显式循环完成上述操作。\n",
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样做是有效的，但当矩阵`x`特别大时，在Python中计算显式循环就将变得非常缓慢。其实将向量`v`加到矩阵`x`的每一行相当于将向量`v`拷贝多次垂直堆叠成矩阵`vv`，然后对矩阵`x`与矩阵`vv`进行按元素求和。我们也可以这样实现该方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "vv = np.tile(v,(4, 1))  # 拷贝4次向量v，然后将其堆叠起来。\n",
    "print(vv)                 # 打印   \"[[1 0 1]\n",
    "                         #          [1 0 1]\n",
    "                         #          [1 0 1]\n",
    "                         #          [1 0 1]]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "y = x + vv  # 矩阵x和矩阵vv按元素相加\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy广播机制允许我们不创建多次向量v备份的情况下执行该计算："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 矩阵x的每一行加上向量v，将结果储存在矩阵y中。\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = x + v  # 使用广播将v加到矩阵的每一行上。\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于广播机制的原因，即使`x`的形状为`(4, 3)`，`v` 的形状为`(3,)`，表达式`y = x + v`依然可以执行；这就好像将`v`拷贝重塑为`(4, 3)`的矩阵，然后进行按元素相加。\n",
    "对两个数组使用广播机制要遵守下列规则：\n",
    "\n",
    "1. 如果数组的秩不同，将秩较小的数组进行扩展，直到两个数组的尺寸长度都一样。\n",
    "2. 如果两个数组在某个维度上的长度是一样的，或者其中一个数组在该维度上长度为1，那么我们就说这两个数组在该维度上是相容的。\n",
    "3. 如果两个数组在所有维度上都是相容的，他们就能使用广播。\n",
    "4. 广播之后，两个数组的尺寸将和较大的数组尺寸一样。\n",
    "5. 在任何一个维度上，如果一个数组的长度为1，另一个数组长度大于1，那么在该维度上，就好像是对第一个数组进行了复制。\n",
    "\n",
    "\n",
    "如果感觉没有解释清楚，详细文档请参考以下网址：(http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) 或者更具体的解释(http://wiki.scipy.org/EricsBroadcastingDoc).\n",
    "\n",
    "支持广播机制的函数也被称为通用函数(universal functions)。你可以更具以下网址查看所有的通用函数(http://docs.scipy.org/doc/numpy/reference/ufuncs.html#available-ufuncs).\n",
    "\n",
    "以下是广播一些应用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  5]\n",
      " [ 8 10]\n",
      " [12 15]]\n"
     ]
    }
   ],
   "source": [
    "#计算向量外积 \n",
    "v = np.array([1,2,3])  # v 形状(3,)\n",
    "w = np.array([4,5])    # w 形状(2,)\n",
    "# 要计算外积，我们首先要重塑v为一列(3, 1)，\n",
    "# 然后将其与w(2,)相乘，输出一个形状为（3,2）的矩阵，其就是v与w的外积。\n",
    "print(np.reshape(v,(3, 1)) * w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 4 6]\n",
      " [5 7 9]]\n"
     ]
    }
   ],
   "source": [
    "# 将向量加到矩阵中的每一行\n",
    "x = np.array([[1,2,3], [4,5,6]])\n",
    "# x 形状(2, 3) ，v 形状(3,) ，广播之后的形状(2, 3),\n",
    "print(x + v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "# 将向量加到矩阵的每一列\n",
    "# x 形状(2, 3)，w 形状(2,).如果我们将x进行转置，那其形状就被重塑为(3, 2)，\n",
    "# 然后将其与w进行广播，就可以生成形状为（3,2）的矩阵；\n",
    "# 我们最后再将结果进行转置，就可以得到形状为（2,3）的矩阵；\n",
    "# 其结果就是将向量w加到矩阵x的每一列\n",
    "print((x.T + w).T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "#另一种更简单的方法是将w重塑为形状为（2,1）的行向量；\n",
    "#然后直接与x进行广播就可产生相同的结果\n",
    "#注意(2,)表示的是秩为1的向量，(2,1)表示的是秩为2的矩阵\n",
    "print(x + np.reshape(w,(2, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4  6]\n",
      " [ 8 10 12]]\n"
     ]
    }
   ],
   "source": [
    "# 矩阵各元素乘以一个常数:\n",
    "# x 形状(2, 3). Numpy 将标量作为数组（）;\n",
    "print(x * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "广播使你的代码简洁而高效，因此你应该尽可能的使用广播操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上仅仅是一些numpy的重要用法，但其功能远不止这些。详细的文档请参考如下网址：(http://docs.scipy.org/doc/numpy/reference/) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matplotlib是一个绘图工具库。下面我们简短的介绍下`matplotlib.pyplot` 模块，其用法和MATLAB相似。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "#使用以下IPython命令行，可以使得绘图结果嵌入到notebook中\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 绘制(Plotting)\n",
    "`matplotlib`最重要的函数就是绘制函数plot,其允许你绘制2D数据。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x20d10089b00>]"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用sin三角函数计算x与y的坐标点\n",
    "x = np.arange(0, 3 * np.pi, 0.1)\n",
    "y = np.sin(x)\n",
    "# 使用matplotlib绘制坐标点\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "添加标题，说明，坐标轴标记到图表中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20d13595978>"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.arange(0, 3 * np.pi, 0.1)\n",
    "y_sin = np.sin(x)\n",
    "y_cos = np.cos(x)\n",
    "\n",
    "# 使用matplotlib绘制坐标点\n",
    "plt.plot(x, y_sin)\n",
    "plt.plot(x, y_cos)\n",
    "plt.xlabel('x axis label')\n",
    "plt.ylabel('y axis label')\n",
    "plt.title('Sine and Cosine')\n",
    "plt.legend(['Sine', 'Cosine'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 子图(Subplots)\n",
    "你可以使用subplot函数在一副图中绘制不同的子图。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEICAYAAABCnX+uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA8N0lEQVR4nO3dd1zVZf/H8dfFYW8FFAUBBwqKynJmNmxoWpppjjQtuy2btve4W3e71OwuV5qZZplZVlqZlZYLBBRFBcGBqIAIyF7X7w/w/llpOQ58z/g8Hw8fDznAOe9zhLfX9zrf6/oqrTVCCCGsl4PRAYQQQlwYKXIhhLByUuRCCGHlpMiFEMLKSZELIYSVkyIXQggrJ0Uu7JZS6ial1PdG5xDiQik5j1zYOqVUP+A1oAtQC6QBU7XWWwwNJoSZOBodQIjGpJTyBlYCU4ClgDNwMVBpZC4hzEmmVoSt6wigtV6sta7VWpdrrb/XWm9TSk1USq0/+YVKKa2UukMpla6UOq6UmqmUUqd8/lalVFrD51YrpUKNeEJC/JkUubB1e4BapdQCpdQgpVSzf/j6IUAPoDtwI3A1gFJqGPAEMBwIANYBixsrtBDnQopc2DStdTHQD9DAbCBPKfWVUqrlGb7lFa11odb6ALAWiG64/XbgP1rrNK11DfAyEC2jcmEJpMiFzWso34la62AgCmgNvHOGLz9yyt/LAM+Gv4cC05RShUqpQqAAUEBQo4QW4hxIkQu7orXeBcynvtDPxUHgdq217yl/3LTWv5s9pBDnSIpc2DSlVIRS6kGlVHDDx22AMcDGc7yr94HHlVJdGu7HRyk10rxphTg/UuTC1p0AegGblFKl1Bd4KvDgudyJ1no58CqwRClV3HAfg8ycVYjzIguChBDCysmIXAghrJwUuRBCWDkpciGEsHJS5EIIYeUM2TTL399fh4WFGfHQQghhtRITE/O11gF/vt2QIg8LCyMhIcGIhxZCCKullNp/utvNMrWilJqnlMpVSqWa4/6EEEKcPXPNkc8HBprpvoQQQpwDs0ytaK1/VUqFmeO+bE15VS0J+wvYfeQE6UdLyMgrobi8mqraOqpq6nBzMhHo40qgjythfh70CGtOTIgvrk4mo6ML0eT2Hytlw95jZOaXkpVfyoFjZVTU1KI1aDReLk6ENHcnxM+dDgGe9O3gR3Azd6NjG67J5siVUpOByQAhISFN9bCGKCqvZlXqYX7Ymcv6jDwqqusA8PNwpkMLT9oHeOLi5ICzyYGyqloOF5Wzce8xlicdQmtwdnQgNsSXodFBDOnWCi9XJ4OfkRCNQ2tN4v7jfJ2Swy978th3rAyo/x0Ibe5OqJ8HHi4mFKCUorCsivTcE/y0O5eqmvrfq3b+HvTvGMCIuGCignwMfDbGMdsS/YYR+Uqt9T/uKhcfH69t8c3OvXklzP9tH8u2ZlNWVUuQrxtXRLbgsogWdA3ywc/T5W+/v6ismi37CtiUdYy1u/PIyC3B1cmBa7q2YlK/tnRpbZ8/pML2lFXV8GVSDgs37iftcDFuTib6tPfjko4B9Av3J8zPA5ODOuP319VpMvJKWJeez/r0PH7fe4zKmjq6B/swtlcIQ6ODbPKoVimVqLWO/8vtUuQXbl9+Ka98t4tVO47gbHLguujWTOgTRlSQN6dcKeycaK1JyS5iacJBvkrOoaSyhmu6BnL/FR0Jb+ll5mcgRNOorq1jyeYDTFuTTn5JFZGtvLm5TyhDo1vj7nz+EwRF5dUs35rNJ5sPsOdoCa18XLn/io4Mjw3C0WQ7y2WkyBtBUXk1M9aks2DDPpxNDkzq15bxfcII8Pr7kff5PM7cdZnM+20fpVU1jIwL5olrIvF1dzbr4wjRmFbvOMIr3+0iK7+Unm2b89BVnegR1uy8Bzuno7Xm973HeG31blIOFtKhhSdPDY7k0k4tzPYYRmrUIldKLQYuBfyBo8CzWuu5Z/p6WyjyH3Ye5fEvtnGstIqRccE8dFUnWni7NupjHi+t4r2fM5j32z6auTvx3HVdGNy1lVl/EYQwt2MllTy9IpVvtx8hvIUnjw2K4PKIFo36c6u1ZlXqEV5fvZvM/FJuiA3mmSGd8XG37vebGn1Efi6suchPVFTzwsqdLE3IpnMrb14b0a3J32DZkVPEY8u2s/1QEVd2bslrN3SjmYeMzoXl+W77YZ76MpUTFTVMvTKcyRe3a9KpjsqaWmasyeC/v+zFz8OZ/wzvyoDIM12u1fJJkZvB9uwipixKJKewnCmXtue+AR1xdjRm/q2mto55v2Xx+urdtPBy5d2xMcSE/NMF4oVoGlU1dTy/cgcfbzxA1yAf3ryxOx0NfG8n9VARD32Wwq4jJ7j9knY8fFUnq5w7lyK/QMuTsnls2Xb8PV2YPiaauNDmRkcCIOVgIXcu2kruiQqeuCaSiX3DZKpFGOpIUQVTFiWSdKDQokqzsqaW57/eyaJNB+jTzo/pY2LM/n5WY5MiP081tXW88t0u5qzPone75swcG/uPpxE2taKyah78LJkf03IZ07MNLwyNsohfHGF/Evcf5/aFCZRX1fL6yO5c07WV0ZH+YlliNk8s304zd2fmToy3qtN6z1Tk8tv+Nyqqa7nj40TmrM9iYt8wFk7qZXElDuDj7sTsm+O5+7IOLN58kEkLEiiprDE6lrAzP+w8ytjZG/F0ceTLuy6yyBIHuCEumC/u7ItSMOqDjfyWkW90pAsmRX4GReXVjJ+7iTW7cnlhaBeeu64LThY8ylVK8dDVnfjP8K6sz8hn5PsbyC2uMDqWsBOLNx/g9oUJRAR6sWxKX4tf69CltQ9f3NmXIF83Jn64mS+TDhkd6YJYbjMZKLe4glEfbCD5YCEzxsQwvk+Y0ZHO2pieIcydEM/+Y6WMmrWRw0XlRkcSNu7dn9J5/Ivt9O8YwOLJvS3yqPV0Wvm4sfSOPsSFNmPqp8ks+H2f0ZHOmxT5nxwtrmDUrI0cKChj3sQeDOnW2uhI5+zSTi1YOKkn+ScqufGDDRwsKDM6krBR7/y4hze+38PwmCBm3xx/QaszjeDj5sSCW3tyVeeWPPvVDuatzzI60nmRIj9F7okKxszeSG5xBQsn9eTi8L9ciMNqxIU25+PbelFUVs3oWRvZf6zU6EjCxrzz4x7e+TGdEXHBvD6yu0VPPf4dF0cTM2+KZWCXQJ5fuZM56zKNjnTOrPOVbwR5JyoZO3sTR4oqmH9rT4s5vfBCdG/jyyf/6k1ZVQ1jZ2+SaRZhNtN+TP9fib96Q7e/3eDKGjiZHJgxNoZrugby4jdpVlfmUuTUn743bs4mDh0vZ97EHvQIs/4SPykqyIeFk3pRXF7/HI+VVBodSVi5eeuzePvHPdwQaxslfpKTyYFpo/+/zD9LOGh0pLNm90VeUV3LpAVbyMovZc6EeHq38zM6ktlFBfkwZ0I82cfLmfDhZoorqo2OJKzUl0mHeH7lTgZ2CeS1EbZT4ic5mRx4e1Q0F4f789gX2/l+xxGjI50Vuy7ymto67v4kicQDx3lrVHcu6uBvdKRG06udH++Pi2PX4RP8a0EClTW1RkcSVmbt7lwe+iyFPu38eGd0tM2V+EkujibeHxdHVJAPdy9OYsPeY0ZH+kd2W+Raa576MpUf047y3LVdrPLslHN1WUQL3ryxO5uyCnjk823U1TX9ql5hnVIOFjLl40QiWnkx6+Y4m7xow6k8XByZP7EHoc3dmfxRAnuOnjA60t+y2yJ/7+e9LNlykLsv68CEvmFGx2kyQ6ODeGRgJ1Yk5/DWD3uMjiOsQPbxMiYtSCDAy4X5t/S0m0sPNvNwZv6tPXF1NnHLh1vIO2G57y/ZZZF/s+0wr6/ezbDo1jx4VUej4zS5KZe0Z0zPNry7NoMlmw8YHUdYsOKKaibNr5+K+3BiD/ytZLGPuQT5ujF3QjzHSiu57aP6PWQskd0VecrBQh5YmkxcaDNeuaGbXe4UqJTi+aFR9O8YwJNfpvK7Dew1Iczv5HtIe/NKeH9cHB1aWPay+8bSLdiXaaNj2JZdyP2fJlvklKRdFXlOYTm3fVR/iPjBeNuf5/s7TiYHZo6NoZ2/B3d+spUDx2T1p/ijF79J49c9ebw4LMqmTwQ4G1d3CeTJayJZteMI76xJNzrOX9hNkVdU13L7wkTKq2qZZ4eHiKfj5Vq/a6LW8K+PZMdE8f+WJhxk/u/7mNSvLaN7hhgdxyJM6teWEXHBTF+TzqrUw0bH+QO7KHKtNU8uT2X7oSLeHhVt6JVKLE2Yvwfvjo0hPfeExR42iqaVdOA4Ty1P5aIOfjw+KMLoOBZDKcWLw6KIbuPLA0tT2HWk2OhI/2MXRb7g930s25rNfQPCubKz9V6vr7FcHB7Ak4M788POo0z/yfIOG0XTyS2u4I6PE2np48K7Y2LlAiV/4upk4oPxcXi6OPKvjxI4XlpldCTADop8U+YxXvgmjSsiW3LfgHCj41isWy8K4/qYIKatSefn3blGxxEGqK6t485FWykur2HW+Hi5oPcZtPR25f3xcRwtqmSqhRzF2nSR5xZXcNcnSYT6ufPWqO442OhKNHNQSvHy9V3p1NKL+5Yky9a3duiV73aRsP84r47oRmQrb6PjWLTYkGY8c21nftmTZxFHsTZb5CdPnSqtrOH9cXF428kihgvh5ly/NLlOa6YsSqSi2jLPmRXm9822w8xtuKThdd1tf5WzOdzUK4ThsZZxFGuzRf7697vZvK+A/wzvKm9unoMwfw/evjGa1EPFPPfVDqPjiCawN6+ERz5PISbElyeuiTQ6jtVQSvHSsPqj2KmfJpN93LijWJss8u93HOGDXzIZ1zuEYTFBRsexOld0bsmdl7ZnyZaDLE/KNjqOaETlVbVM+TgRFycT790Ui7OjTVZCozl5FFtbq7nrkySqauoMyWFz/2oHC8p48LMUugX78PSQzkbHsVoPXNmRnm2b8+TyVDJyS4yOIxrJs1+lkp5bwjujomnl42Z0HKsU5u/BayO6kXKwkFdX7TIkg00VeVVNHXcvTgJg5thYXBztd+XmhXI0OTBjTAxuTibuWrTVYveYEOfvi63ZLE3I5u7LOtC/o/Ve1tASDOraiol9w5i7PsuQPcxtqshfW7WLlIOFvD6iG22auxsdx+q19Hbl7VHR7Mk9wbNfpRodR5hRRu4JnlyeSs+2zeW0XDN5/JoIugb58NBnKU1+1pfNFPmPO48yZ30WE/qEMjCqldFxbEb/jgHcdWkHliZksyL5kNFxhBlUVNdy16Ik3JxNTB8dI4t+zMTF0cTMsbFoDfcsTqK6tunmy23iXzCnsJyHPk+hS2tvHpd33c1u6hXhxIc248nlqezLLzU6jrhAz6/cye6jJ3jrxu4E+rgaHcemhPi588oN3Ug+WMib3zfdfv9WX+S1dZqpS5Kprqnj3bGxdr2jYWNxNDkwbUwMJgfFPYuNe2deXLjvth/mk00HuL1/Oy7t1MLoODZpcLdWjOkZwvu/7OXXPXlN8phWX+Qzfkpn874CXhgWRVt/D6Pj2KwgXzdeG9GN7YeKDHtnXlyY7ONlPLpsG92DfXjwqk5Gx7FpzwzpTMeWnjywNKVJrixk1UW+OauA6WvSGR4TxPDYYKPj2LyruwQyoU8oc9dnsVb2Y7EqNbV1TF2STJ2GGWPkfPHG5uZsYsaYWE5UVPPA0sbfj8Vq/zULy6qYuiSJkObuPD8syug4duPxayKJCPTioaUp5J6oMDqOOEvT16STsP84L10fRYifnNHVFDoFevHMtZ1Zl57PnPWZjfpYVlnkWmseW7advJJKZoyJxdPF0ehIdsPVycSMMTGUVtXw4NIUi9j5Tfy9jZnHeHdtBiPjghkaLSudm9LYniEM7BLI66t3sz27qNEexyqLfPHmg6zacYRHro6ga7CP0XHsTnhLL54e0jQjDXFhCsuquP/TZEL9PHjuui5Gx7E7SileuaEr/p4u3LukfhO/xmCWIldKDVRK7VZKZSilHjPHfZ5J+tETPL9yBxeH+zOpX9vGfCjxN06ONF5btZtt2YVGxxGnobXm0WXbyC+pZProGDzkyNUQvu7OvD0qmn3HSnm2kTaiu+AiV0qZgJnAIKAzMEYp1SibnFRU13LP4iQ8nB1580bZX9xIJ0caAV4u3Ls4Sa73aYE+2XyA1TuO8vDVneTI1WC92/lx92Ud+Dwxm9WNsITfHCPynkCG1jpTa10FLAGGmuF+/+K1VbvZdeQEb4zsTgsvWchgtJMjjf0FZbLlrYVJP3qCF1bu5OJwf27r187oOAK4b0A4jw6M4OJwf7PftzmKPAg4eMrH2Q23/YFSarJSKkEplZCXd34nyV/TNZCHr+7EZRGykMFSnDrS+Colx+g4gv8/cnV3duTNkXLkaikcTQ5MubQ97s7mn+IyR5Gf7qfkL6cyaK1naa3jtdbxAQHnt9NafFhz7rqsw3l9r2g89w4IJybElye/2C6XiLMAr67a1XDk2o0W3nLkag/MUeTZQJtTPg4GZGhmR5xMDkwfHQPAfUuSqGnCzYLEH63dlcuHv+1jYt8wLo9oaXQc0UTMUeRbgHClVFullDMwGvjKDPcrrEib5u68eH0UWw8UMm2N8RejtUe5xRU89FkKEYFePDYowug4ogldcJFrrWuAu4HVQBqwVGst73zZoaHRQYyIC+bdtRls2HvM6Dh2pa5O88DSFEqrapgxJkY2j7MzZjmPXGv9rda6o9a6vdb6JXPcp7BO/76uC2F+Htz/aTLHS6uMjmM3Pvg1k/UZ+Tx7bRfC5WLjdscqV3YKy+Xh4siMMTEcK63kkWXb0FqW8De2pAPHefP73Qzu2orRPdr88zcImyNFLswuKsiHRwdG8MPOo3y0Yb/RcWxacUU19y5JoqW3Ky8P74pScqqhPZIiF41iUr+2XB7Rgpe+SSP1UONtFmTPtNY8/sV2cgormD4mGh83J6MjCYNIkYtGoZTijZHdaebhxD2yhL9RfLL5AN9sO8yDV3UkLrS50XGEgaTIRaNp7uHMtNEx7D9WytNfpsp8uRmlHS7m+a/rl+Df0b+90XGEwaTIRaPq3c6PeweEszzpEJ8lZBsdxyaUVdVw9ydb8XZz4u1R0bIEX0iRi8Z3z+XhXNTBj6dXpJJ2uNjoOFZNa82Ty1PJzC9l2qho/D1djI4kLIAUuWh0JgfFO6Ni8HFz4q5FW2W+/AIs3nyQ5UmHmDqgI307mH8XPWGdpMhFkwjwcmH6mBj2HSvl8S+2y3z5eUg9VMRzX+2gf8cA7rlcNo8T/0+KXDSZ3u38ePCqTnydksOC3/cZHceqFJVXM2VRIn6ezrwj8+LiT6TIRZOackl7rohswYvfpLFlX4HRcaxCXZ3mwaXJHC6s4N2xsTT3cDY6krAwUuSiSTk4KN68MZrgZm7cuWgrucUVRkeyeDN+yuDHtFyeGhxJXGgzo+MICyRFLpqcj5sT74+Po6Sihrs+2Uq17F9+RmvSjvL2j3sYHhvEhL5hRscRFkqKXBgiItCbV27oypZ9x3lh5U6j41ikrPxSpn6aTFSQNy9fL/uoiDMz/8XjhDhLQ6ODSD1UxOx1WXQK9OKmXqFGR7IYxRXVTP4oAUcHxfvj4mR/cfG3ZEQuDPXYoEgu7RTAsyt2yMUoGtTU1nHPJ0lk5Zfy3k1xBDdzNzqSsHBS5MJQJgfF9DExhPq5c+eiRA4ck4s3v/RtGr/syePFYVH0ae9ndBxhBaTIheG8XZ2YM6EHdRpuXbCForJqoyMZZtGm/Xz42z4m9WvL6J4hRscRVkKKXFiEtv4evD8ujgPHypi8MIHKmlqjIzW5tbtzeWbFDi7rFMAT10QaHUdYESlyYTH6tPfj9ZHd2JRVwEOfbaOuzn6W8accLOTOj7cSEejF9DExmGTlpjgHctaKsChDo4PIKazg1VW7aO3jyuN2MDLdl1/KrfO34O/lzIe39MDLVa70I86NFLmwOHdc0o6cwnI++DUTX3dnplxquxdOyD1Rwc3zNqOBBbf0pIWXq9GRhBWSIhcWRynFc9d1obiimldX7cLDxcTNfcKMjmV2x0oquWn2JvJLKll0Wy/aBXgaHUlYKSlyYZFMDvXX/CyrquWZFTtwd3ZkRFyw0bHMprCsinFzN3OgoIz5t/QkJkT2UBHnT97sFBbLyeTAjDEx9OvgzyOfp7A8yTYuFVdcUc3N8zazN7eE2TfHy7ni4oJJkQuL5upkYtbNcfRu58cDS1P4ZNMBoyNdkGMllYydvZG0w8X8d1ws/TsGGB1J2AApcmHx3J0dmTexB5d2DOCJ5duZuz7L6Ejn5XBROTd+sIH0oyV8MD6OAZEtjY4kbIQUubAKrk4mPhgfz6CoQF5YuZM3Vu+2qvPMs/JLGfHfDeQWV7JwUi8uj5ASF+YjRS6shrNj/Zz5qPg2vLs2g3uXJFFRbfkrQDfsPcbw936jvLqWxZN707Ntc6MjCRsjZ60Iq+JocuCVG7rSNsCDV77bxaHCcmbfHI+/p4vR0U5r0ab9PLtiB6F+7syd0IMwfw+jIwkbJCNyYXWUUtxxSXv+e1MsaYeLGTJ9PZsyLWsL3IrqWp7+MpUnl6fSL9yf5XddJCUuGo0UubBag7q24vM7+uLmbGLM7I3MWJNOrQXMm+8+coJhM39j4cb9TO7fjrkTeuAty+5FI5IiF1YtKsiHr+/px7XdW/PmD3u4ac5GMvNKDMlSV6eZ/1sW1767nvySSj6c2IMnromUDbBEo1NaN/0IJj4+XickJDT54wrbpbXms8RsXli5k8rqOqZc2p4pl7ZvskukJR8s5NmvdpBysJDLOgXw2ojuBHhZ5ry9sF5KqUStdfyfb5c3O4VNUEpxY3wbLu0UwIsr05i2Jp0VyYeYekVHhnRrhaOpcQ4+DxeV89b3e/gsMZsALxfeHNmd4bFBcqFk0aRkRC5s0rr0PF5cmcbuoydo6+/BnZe257ro1rg4mmeEvutIMbN+zeSr5ByUglsvass9A8LxdJGxkWg8ZxqRX1CRK6VGAs8BkUBPrfVZtbMUuWgKdXWa73ceZfqadHYeLsbb1ZHB3VozPDaIuJBmOJzj3PXR4gpWpR7h2+2H2ZRVgJuTiVE92jCpX1vaNJcLJIvG11hFHgnUAR8AD0mRC0uktWZdej7Lkw6xKvUI5dW1+Lg5ERPiS1xIMyJbeePv5YKfhzPerk6UVddQWllDYVk1u46cYOfhYlIPFbEtuwiA8BaeDI1uzU29Qmnm4WzwsxP2pFHmyLXWaQ13fiF3I0SjUkrRv2MA/TsG8OKwGn5MO8qGvcdI3H+cn3fn/eP3e7s60rm1Nw9c2ZFBUYGEt/RqgtRCnL0mm9BTSk0GJgOEhMjVwYUxPFwcGRodxNDoIACKyqrJOlZKQWkl+SVVnKiowd3ZhIeLI16ujnQI8CS4mZsMVoRF+8ciV0r9CASe5lNPaq1XnO0Daa1nAbOgfmrlrBMK0Yh83J2Idvc1OoYQF+Qfi1xrfUVTBBFCCHF+ZGWnEEJYuQs9a+V6YAYQABQCyVrrq8/i+/KA/ef5sP5A/nl+r62Q10BeA3t//mCfr0Go1vovl5UyZEHQhVBKJZzu9Bt7Iq+BvAb2/vxBXoNTydSKEEJYOSlyIYSwctZY5LOMDmAB5DWQ18Denz/Ia/A/VjdHLkRTUUrtAO7SWv9sdBYh/o41jsiFOC2l1FilVIJSqkQpdVgp9Z1Sqt/53p/WuouUuLAGUuTCJiilHgDeAV4GWgIhwHvAUANjCdEkrKrIlVIDlVK7lVIZSqnHjM7TlJRSbZRSa5VSaUqpHUqp+4zOZBSllEkplaSUWtnwsQ/wPPXTIF9orUu11tVa66+11g8rpVyUUu8opXIa/ryjlHJp+F5/pdRKpVShUqpAKbVOKeXQ8Ll9SqkrGv7+nFJqqVLqI6XUiYZ/g/hTMrVWSi1TSuUppbKUUvc24vP3VUp9rpTa1fDz0KexHstSKaXub/g3SFVKLVZKuRqdyUhWU+RKKRMwExgEdAbGKKU6G5uqSdUAD2qtI4HewF129vxPdR+QdsrHfQBXYPkZvv5J6l+zaKA70BN4quFzDwLZ1C9qawk8AZzpjaPrgCWAL/AV8C5AQ/F/DaQAQcAAYKpS6h8Xx52nacAqrXUE9c8n7R++3qYopYKAe4F4rXUUYAJGG5vKWFZT5NT/8mVorTO11lXU/0LZzWGz1vqw1nprw99PUP/LG2RsqqanlAoGBgNzTrnZD8jXWtec4dtuAp7XWudqrfOAfwPjGz5XDbSifsVctdZ6nT7zGQDrtdbfaq1rgYXUlyhADyBAa/281rpKa50JzKYRykUp5Q30B+YCNDxeobkfxwo4Am5KKUfAHcgxOI+hrKnIg4CDp3ycjR0WGYBSKgyIATYZHMUI7wCPUH9Bk5OOAf4Nv9Sn05o/bgmxv+E2gNeBDOB7pVTmP0zZHTnl72WAa8NjhgKtG6ZnCpVShdSP7Fue3VM6J+2APODDhumlOUopj0Z4HIultT4EvAEcAA4DRVrr741NZSxrKvLTbQhtd+dOKqU8gWXAVK11sdF5mpJSagiQq7VO/NOnNgAVwLAzfGsO9WV7UkjDbWitT2itH9RatwOuBR5QSg04x2gHgSytte8pf7y01tec4/2cDUcgFviv1joGKAXs7f2iZtQfjbel/j9kD6XUOGNTGcuaijwbaHPKx8HY2eGUUsqJ+hJfpLX+wug8BrgIuE4ptY/6qbXLlVIfa62LgGeAmUqpYUopd6WUk1JqkFLqNWAx8JRSKkAp5d/wtR9D/X8OSqkOqv7KEcVAbcOfc7EZKFZKPaqUcmt4MzZKKdXDLM/6j7KBbK31yaOxz6kvdntyBfX/ceZprauBL4C+BmcylDUV+RYgXCnVVinlTP3841cGZ2oyDUUzF0jTWr9ldB4jaK0f11oHa63DqP/3/0lrPa7hc28BD1D/JmYe9aPku4EvgReBBGAbsB3Y2nAbQDjwI1BC/cj+vXM9d7xhzvxa6t9MzaJ+R745gM95PdG/f6wjwEGlVKeGmwYAO839OBbuANC74T9sRf1rYFdv+P6ZVa3sVEpdQ/0cqQmYp7V+ydhETadhYcs66ovo5PzwE1rrb41LZRyl1KXUX/B7iMFRmpxSKpr6/yicgUzgFq31cUNDNTGl1L+BUdSfzZUE3Ka1rjQ2lXGsqsiFEEL8lTVNrQghhDgNKXIhhLByUuRCCGHlzrSAolH5+/vrsLAwIx5aCCGsVmJiYv7prtlpliJXSs0DTi7WiPqnrw8LCyMhIcEcDy2EEHZDKXXai9aba2plPjDQTPclhBDiHJhlRK61/rVh/49GlXa4mLwTlfi6O+Hj5kRzD2e8XJ0a+2GFsBrHS6vIK6mktLKG8qr6Bar+Xi4EeLrg4+aEg8PpdroQ1q7J5siVUpOByQAhISHndR8fb9zPok0H/nBbSHN3ugX7EN3Gl8siWtA+wPOCswphDbTWbD9UxI87j7LtUBFph4s5WnzmNTEujg50D/YlLqwZPcKa0be9P65OpiZMLBqL2RYENYzIV57NHHl8fLw+nznynMJycgrLKSyrpqi8miPFFWzPLmJbdiE5RRUAdGntzbXdW3N9TBAtve16r3lhozJyT7Bo0wFWpx4hp6gCk4MivIUnka28iWzlRSsfNzxdHHF3NlGnIb+kkvySSg4UlLF1/3F25BRTU6fxcnHkmq6tuD42iJ5hzWW0bgWUUola6/i/3G5NRf53cgrL+S71CF+n5JB8sBBnkwM3xAVxe//2hPnb1S6fwgZprdmUVcDsXzNZsysXZ0cH+ocHMDAqkAERLWjm4XzW91VeVcuWfQWsSM7hu9TDlFXV0rGlJ/cOCOeaqFZS6BbM5ov8VPvyS5mzPpOlCdnU1NYxLDqIxwZF0EJG6MIKpR0u5vmvd7Ih8xjNPZy5uU8o43uH4ufpcsH3XVZVw3fbj/DfX/aSkVtCeAtPHriyIwOjAqnfj0pYkkYtcqXUYuBSwB84CjyrtZ57pq9v7CI/Kbe4gjnrs5j/+z6cTQ7cf2VHJvQJxdEk66CE5TteWsVbP+xh0ab9eLs5MXVAOKN7hjTKvHZtnebb7YeZviad9NwSLukYwIvDomjT3N3sjyXOX6OPyM9FUxX5SfvyS3n2qx38siePiEAv3hkdTUSgd5M9vhDnau2uXB7+PIXjZdWM6xXC/Vd2xNf97KdPzldtneajDft4Y/VuarXmvgEdmdy/HSaZbrEIdl3kUD/HuHrHUZ5ekUpReTVPDY5kfO9QOXwUFqW8qpaXv01j4cb9RAR68faoaCJbNf2g43BROc+u2MH3O4/Su11zpo2OkZMHLIDdF/lJ+SWVPPRZCj/vzuOKyJa8MbJbk4x0hPgnmXklTF6YSEZuCbf1a8vDAzvh4mjc6YFaaz5PzOaZFTtwdzbx9qho+nf8y+pw0YTOVOR2N1ns7+nCvAk9eHpIZ37Zk8v17/1OZl6J0bGEnftlTx5DZ/5GQWkVH0/qxVNDOhta4gBKKUbGt+Gruy/Cz9OZCR9uZubaDOQaBpbH7oocwMFBMalfWz75V2+Kyqu5/r3f+T0j3+hYwg5prZmzLpNbPtxMkK8bK+66iH7h/kbH+oPwll6suKsf13Zrzeurd/Posm1U19b98zeKJmOXRX5Sj7DmrLjrIlp6u3DzvM0s3XLQ6EjCjtTVaf799U5e/CaNqzoHsmxKX4s9S8TN2cS00dHce3kHliZkM/HDzRSVVxsdSzSw6yIHaNPcnWVT+tKnvR+PLNvG3PVZRkcSdqC6to4HP0th/u/7mNSvLe/dFIuHiyG7Sp81pRQPXNWJN0Z2Z3NWAaNnbeRYid1eJtOi2H2RA3i5OjFnQjyDogJ5YeVOpq9Jl3lA0WgqqmuZ8nEiy5MO8dBVHXlqcKRVraYcERfMnAk9yMwrYdSsjeQWVxgdye5JkTdwcTQxY0wMN8QG89YPe3jlu11S5sLsKqpr+ddHCazZlcsLw6K4+/JwqzwF9pKOAcy/pSc5heXc+MEGDhWWGx3JrkmRn8LR5MDrI7oxvncoH/yayVs/7DE6krAhVTV13LloK+vS83n1hvqfM2vWp70fCyf14lhJFaNnbeBIkYzMjSJF/icODop/X9eFUfFtmPFTBjPXZhgdSdiA6to67v5kKz/tyuXl67tyY3wboyOZRVxoMxbe1ouCkirGzd0kc+YGkSI/DQcHxcvDuzI0uv50q3nyBqi4AHV1mgeXpvD9zqP8+7oujO11fvvxW6roNr7MndiDgwVl3DxvM8UVcjZLU5MiPwOTg+LNkd0Z2CWQ51fuZEXyIaMjCSukteaFb3byVUoOjw6MYELfMKMjNYre7fx4f3wce46eYNL8LVRU1xodya5Ikf8NR5MD08ZE07tdcx76LIXfZNGQOEezfs3kw9/2cetFbbnjknZGx2lUl3VqwTujYkjYf5ypS5KprZOTBZqKFPk/cHE08cH4eNr5e3LHwkTSDhcbHUlYieVJ2fznu10M6daKpwZHWuXZKedqcLdWPD24M6t2HOGlb9KMjmM3pMjPgo+bEx/e0gMPF0cmfriZHDnVSvyDjZnHePizbfRp58ebN3a3qvPEL9St/dpy60VtmfdbliywayJS5Gepta8b82/tQWllLbctSKCsqsboSMJC7csv5Y6PEwn1c+f98XGGb35lhCcHRzKwSyAvfrOT73ccMTqOzZMiPwcRgd5MHxNN2pFiHlyaQp3MAYo/KSqvZtKCLQDMndADHzcngxMZw+SgeGd0NN2CfZn6aTK7jsiUZGOSIj9Hl0e05IlBkXyXeoR3fpQFQ+L/1TScK36goIz3x8XZ/UW/XZ1MzBofh6eLI7ctSJBzzBuRFPl5uO3itoyMC2b6Txl8nZJjdBxhIV75bhfr0vN5cVgUvdv5GR3HIrT0dmXWzfHknqhkyqKtVNXI9reNQYr8PCileOn6rsSHNuORz7fJYaNgRfIh5qzPYkKfUEb1sK0FPxcquo0vr93Qjc1ZBbywcqfRcWySFPl5cnZ04L2bYvFydeT2hYmyN7Md25lTzKPLttEzrDlPDelsdByLNCwmiMn927Fw436WJWYbHcfmSJFfgBbervx3XCw5heXc/2myvPlphwrLqrj94wR83ZyZeVMsTib5lTqTR67uRJ92fjyxfDs7coqMjmNT5KfuAsWFNueZIZ35aVcu09akGx1HNKG6Os3UT5M5WlTJf8fFEuDlYnQki+ZocmDG2BiauTtzx8eJFJZVGR3JZkiRm8G43qEMjw1i+k/p/Lonz+g4oom893MGP+/O4+lrOxMT0szoOFbB39OF98bFcqSoQo5izUiK3AyUUrw0rCsdW3gx9dNkDhfJyk9b93tGPm/9sIeh0a0ZZ2O7GTa22JBmPHNtF9buzuP9X/caHccmSJGbiZuziZk3xVJZXcs9nyTJVcZt2NHiCu5dkkS7AE9evr6rXeyhYm7jeoUwpFsr3li9m02Zx4yOY/WkyM2oQwtPXh7elYT9x3l99W6j44hGUFNbxz2LkyitrOW/VnDBZEullOI/w7sS6ufBPYuTyJfFQhdEitzMhkYHMa53CLN+zeSnXUeNjiPMbPqadDZnFfDS9VGEt/QyOo5V83J1YubYWIrKq2W+/AJJkTeCpwZ3pnMrbx5cmiLz5Tbkt4x8ZqzNYGRcMMNjg42OYxM6t/bm39d1YV16Pv/9RebLz5cUeSNwdTLx7tgYKmvquG9xMjUyX2718k5Uct+SZNoHePLvoV2MjmNTRvVow7XdW/PWD3tI2FdgdByrJEXeSNoFePLisCg27ytgupxfbtXq6jQPLE3mREU1746Nwd1Z5sXNSSnFy9dHEeTrxr2Lk+T88vMgRd6IhscGMyIumBlrM/h9r1wmzlrNWpfJuvR8nr22CxGB3kbHsUlerk68OzaGvJJKHvl8G1rLfPm5kCJvZM8P7UJbfw/u/zSZglIZaVibpAPHeWP1bgZ3bcWYnm2MjmPTugX78ujACL7feZSFG/cbHceqSJE3MndnR6aPjuF4aTWPfJ4iIw0rUlxRzb1Lkmjp7crLw+V88aZw60VtubRTAC9+kya7ip4DKfImEBXkw2ODIvgxLZePNshIwxporXlqeSo5hRVMHxNtt1f6aWoODoo3RnbH29WJexcnUV5Va3QkqyBF3kRuuSiMyyNa8NK3aaQdlpGGpVu29RBfpeRw34Bw4kKbGx3Hrvh7uvDWjd3Zc7SEF7+R/cvPhlmKXCk1UCm1WymVoZR6zBz3aWuUUrw+ohs+bk7cIyMNi5aVX8ozK1Lp1bY5d13Wweg4dql/xwBu79+ORZsOsCpVLt78Ty64yJVSJmAmMAjoDIxRSsnu+qfh1zDSyMiVkYalqqqp474lSTiZHHh7VDQmB5kXN8qDV3WiW7APj32xTRbW/QNzjMh7Ahla60ytdRWwBBhqhvu1SReHy0jDkr35w262ZRfx6g3daO3rZnQcu+bs6MC00TFU1dQxdUkytbKE/4zMUeRBwMFTPs5uuO0PlFKTlVIJSqmEvDz73rP7was60TVIRhqWZn16Ph/8ksnYXiEMjAo0Oo4A2vp78O/rurApq4D3ZQn/GZmjyE937PmX/zq11rO01vFa6/iAgAAzPKz1cnZ0YPqY+pHG/Z/KSMMSHCup5P6lyXRo4cnTg2Vm0JKMiAv+3xL+rQeOGx3HIpmjyLOBU1dKBAM5Zrhfm3ZypLExU0YaRtNa8/Dn2ygqr2bGmBjcnE1GRxKnUErx4rAoAr1duW9JEsUVcqHzPzNHkW8BwpVSbZVSzsBo4Csz3K/Nk5GGZVjw+z5+2pXL44MiiGwlS/AtkY+bE9PHRJNTWMFTy1NlYd2fXHCRa61rgLuB1UAasFRrveNC79ceKKV46fooWvm4cu9iGWkYIe1wMS9/t4vLI1owsW+Y0XHE34gLbc7UAeF8lZLDsq2HjI5jUcxyHrnW+lutdUetdXut9UvmuE974e3qxLTRMRwukpFGUyurquGexUn4uDnx+ohusgTfCtx5WQd6tW3OMytSycwrMTqOxZCVnRYgLrTZ/0YanyVmGx3Hbjz/9U725pXw9o3R+Hm6GB1HnAWTg+LtUdE4mRy4d0kSVTWy1z9IkVuMOy/rQO92zXl2xQ4ycmWk0di+TslhyZaD3HFJe/qF+xsdR5yD1r5uvDaiG6mHinlt1S6j41gEKXILYXJQTBtdf8bE3Z9spaJalvA3loMFZTzxxXZiQnx54MqORscR5+HqLoHc3CeUOeuz5Nq4SJFblJberrwxshu7jpzgP9+mGR3HJlXX1nHP4iRQMH10DE4m+RWwVk9cE0lkw7VxjxRVGB3HUPJTbGEuj2jJpH5tWbBhP6tSDxsdx+a8vno3yQcLeWV4N9o0dzc6jrgAf7g27pIku15YJ0VugR4dGEH3YB8e/nwbBwvKjI5jM37adZRZv2YyrncIg7u1MjqOMIP2AZ48PzSKTVkFTLPja+NKkVsgZ0cH3h0bC8Ddn2yVd+bNIKewnAeWptC5lTdPyRJ8mzIiLpgbYoOZ8VM669Ltcx8nKXIL1aa5O6+P6E5KdhH/+U7myy9EdW0d9y5Oorqmjpk3xeLqJEvwbc0Lw7rQIcCTqUuSOVpsf/PlUuQWbGBUILdcFMaHv+3ju+0yX36+Xlu1i4T9x3l5eFfa+nsYHUc0AndnR967KZayqlruWZxETa19HcVKkVu4xwdF0r2NLw9/vk1Wsp2HVamHmb0ui/G9Qxka/ZfdlYUNCW/pxUvXR7E5q4A3vt9jdJwmJUVu4ZwdHXjvplicTIopH2+lrKrG6EhWIzOvhIc+20b3Nr48NSTS6DiiCQyPDWZMzxDe/2WvXV24RYrcCgT5ujF9TAx7ck/w+BfbZT+Ws1BeVcudi7biZFK8d1MsLo4yL24vnruuM92DfXjosxS7OYqVIrcSF4cH8OCVHVmRnMOC3/cZHceiaa15dNk2dh89wTujYwiSS7bZFRdHE++Ni8PJpLjj40RKK23/KFaK3IrceWkHrohswYvfpLFh7zGj41isWb9m8lVKDg9d1YlLOtr31ajsVZCvGzPGxJKRW8Ijy7bZ/FGsFLkVcXBQvDUqmlA/d+76ZKssFjqNX/bk8eqqXVzTNZA7L21vdBxhoH7h/jwyMIJvth1m5toMo+M0KilyK+Pt6sTsm+Oprq1j8sJEefPzFPvyS7nnk610bOnF6yO6y/7igtv7t2NYdGve+H4P3++w3Tc/pcitULsAT2aMiWH3kWIe/mwbdXa8x8RJReXVTFqwBQcHxazx8Xi4OBodSVgApRSv3NCNbsE+3P9pMruPnDA6UqOQIrdSl3ZqwWODIvhm+2He/GG30XEMVV1bx52LEjlQUMb74+II8ZPNsMT/c3UyMWt8PO4ujkxasIW8E5VGRzI7KXIr9q+L2zGmZwgz1+5l6ZaDRscxhNaap79M5beMY/xneDd6t/MzOpKwQIE+rsy5OZ78kkpu+yiB8irb2u9fityKKaV4fmgXLg7354nl21mfnm90pCb3wa+ZLNlykLsv68CIuGCj4wgL1r2NL9NHx7Atu5B7bWzbWylyK+dkql/52aGFJ1M+TmRnTrHRkZrMF1uzeeW7XQzu1kqu9CPOylVdAnl2SGd+2HmUF1butJnTEqXIbYCXqxPzJvbA09WRm+dtZl9+qdGRGt1Pu47y8Ofb6Nvej7du7I6Dg5yhIs7OxIvaclu/tsz/fR/v/bzX6DhmIUVuI1r7urFwUk9q6+oYN3eTTV/6KnF/AXcu2kpkKy8+GB8ny+/FOXvimkiujwni9dW7bWKltBS5DenQwosFt/bkeGkVN8/bxPHSKqMjmV3qoSJunZ9AKx835t/SEy9XJ6MjCSvk4KB4fUQ3ruzckme/2sGyxGyjI10QKXIb0y3Yl9kT4tl3rIyb5myiwIbKPPVQETfN2YSniyMf3doTf08XoyMJK+ZocmDGmBgu6uDHI8u28c02693zX4rcBvVt78/sm+PZm1fC2NkbOVZi/efN7sgpYtzc+hJfMrm3XDhZmMXJc8xjQ3y5Z/FWlidZ58hcitxGXdIxgLkTepCVX8qY2RutehHE9uz6kbi7k4nF/5ISF+bl4eLI/Ft60qutHw8sTbHKNRlS5DasX7g/H07swYGCMm78YAP7j1nf2Sy/7slj1KwNeDg7smRyH1m1KRqFh4sj8yb2oF8Hfx5Zto35v2UZHemcSJHbuL4d/Fl0Wy+Ol1Ux/L3fSTlYaHSks/Zl0iFunb+FUD8Plt/ZV0pcNCo3ZxOzb47nys4tee7rnby4cqfV7GMkRW4H4kKbs2xKX9ycTYyetZE1aUeNjvS3tNbMXJvB1E+TiQ9rxqe396aFt6vRsYQdcHUy8f64OCb2DWPO+izuXLTVKpbzS5HbifYBnnxxZ186tPDkto8SmPZjukWONkoqa5jy8VZeX72b67q3Zv4tPfGWUwxFEzI5KJ67rgtPD+nM6p1HGDVrg8Xv/S9FbkdaeLny6e29GRYdxNs/7uHWBVsoLLOc0xP35pUwbOZv/JB2lKcGRzJtdDSuTrLYRxhjUr+2fDAujqy8UgZPX2fR+5lLkdsZd2dH3rqxOy8Oi+L3jGMMnr6e3zKM3Wyrrk6z4Pd9DJm+noLSKhZO6sltF7eTC0MIw13VJZCV9/YjxM+dyQsTeWHlTiqqLW+qRRmxaUx8fLxOSEho8scVf5R8sJD7P02uP0WxZxsevyayyacxDhaU8eiybfy+9xj9Owbw6g1daeUjF0sWlqWyppaXvknjow37aevvwcvXd6VP+6bfMlkplai1jv/L7VLk9q2iupa3f9jD7HWZtPBy5dFBnbiuexCmRt6EqrSyhlm/ZjJ7XSYKeGpIZ0b3aCOjcGHR1qfn88Ty7fWn9MYH8/DVEQR4Nd0KYyly8bdSDhbyxPLt7MgpJiLQi4eu6sSAyBZmL9bKmlqWJR7i7R/3kHeiksFdW/HYoAhZ5COsRnlVLdPWpDN7XSZOJsWEPmFM7t8OvybYMqJRilwpNRJ4DogEemqtz6qdpcgtU12d5pvth3nrhz1k5ZcSEejF2F4hDI0OwsftwqZcDheV88mmAyzefID8kiriQ5vxxOBIYkOamSm9EE0rK7+UGWvS+TL5EK5OJkbEBTMyrg1RQd6NdmTZWEUeCdQBHwAPSZHbhuraOpZvPcSCDfvYkVOMq5MDV3YO5OIO/vTt4Edws38ePWutycgt4efdeazdncumrALqtGZARAtu7hPGxeH+Mo0ibEJGbgkz12bwzfbDVNXUERHoxZBurejVzo9uwT5m3Wa5UadWlFI/I0Vuk7ZnF/HJ5gP8sPMo+Q2bbwX5uhHq506bZu608nXFpBR1Gmrr6jhUWEFWfgmZ+aUUllUD0LGlJ1dEtmRMzxCZQhE2q6ismq+35fBZYvb/VlA7OzrQpbU3rX3dCPR2paW3C4OiWp3374HhRa6UmgxMBggJCYnbv3//BT+uaDpaa/YcLeG3jHySDhZysKCM7OPl/yv3kwK9XWnr70HbAA+6tPbm0k4tCPKVs1CEfSkorSJhXwGbswpIzSniaHElR4oqKK+u5eNJvegX7n9e93veRa6U+hEIPM2nntRar2j4mp+REbldqq6tA8CkFEoh0yVCnIHWmpLKGpwdHc57uuVMRe54Fg9+xXk9orALTiZZUybE2VBKNdoVreS3UAghrNwFFblS6nqlVDbQB/hGKbXaPLGEEEKcLUMWBCml8oDzfbfTHzB2cxDjyWsgr4G9P3+wz9cgVGsd8OcbDSnyC6GUSjjdZL89kddAXgN7f/4gr8GpZI5cCCGsnBS5EEJYOWss8llGB7AA8hrIa2Dvzx/kNfgfq5sjF0II8UfWOCIXQghxCilyIYSwclZV5EqpgUqp3UqpDKXUY0bnaUpKqTZKqbVKqTSl1A6l1H1GZzKKUsqklEpSSq00OosRlFK+SqnPlVK7Gn4e+hidqakppe5v+D1IVUotVkq5Gp3JSFZT5EopEzATGAR0BsYopTobm6pJ1QAPaq0jgd7AXXb2/E91H5BmdAgDTQNWaa0jgO7Y2WuhlAoC7gXitdZRgAkYbWwqY1lNkQM9gQytdabWugpYAgw1OFOT0Vof1lpvbfj7Cep/eYOMTdX0lFLBwGBgjtFZjKCU8gb6A3MBtNZVWutCQ0MZwxFwU0o5Au5AjsF5DGVNRR4EHDzl42zssMgAlFJhQAywyeAoRngHeIT6K1PZo3ZAHvBhw/TSHKWUh9GhmpLW+hDwBnAAOAwUaa2/NzaVsaypyE+30bXdnTuplPIElgFTtdbFRudpSkqpIUCu1jrR6CwGcgRigf9qrWOAUsDe3i9qRv3ReFugNeChlBpnbCpjWVORZwNtTvk4GDs7nFJKOVFf4ou01l8YnccAFwHXKaX2UT+1drlS6mNjIzW5bCBba33yaOxz6ovdnlwBZGmt87TW1cAXQF+DMxnKmop8CxCulGqrlHKm/s2NrwzO1GRU/aV35gJpWuu3jM5jBK3141rrYK11GPX//j9pre1qJKa1PgIcVEp1arhpALDTwEhGOAD0Vkq5N/xeDMDO3vD9s3+8QpCl0FrXKKXuBlZT/y71PK31DoNjNaWLgPHAdqVUcsNtT2itvzUukjDIPcCihgFNJnCLwXmalNZ6k1Lqc2Ar9WdzJWHny/Vlib4QQlg5a5paEUIIcRpS5EIIYeWkyIUQwspJkQshhJWTIhdCCCsnRS6EEFZOilwIIazc/wHu8fP7yq7dhAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用sin以及cos函数计算x与y的坐标点\n",
    "x = np.arange(0, 3 * np.pi, 0.1)\n",
    "y_sin = np.sin(x)\n",
    "y_cos = np.cos(x)\n",
    "# 设置子图网格，其高为2，宽为1.\n",
    "# 设置使用第一张子图\n",
    "plt.subplot(2, 1, 1)\n",
    "# 绘制第一张子图\n",
    "plt.plot(x, y_sin)\n",
    "plt.title('Sine')\n",
    "# 设置使用第二张子图，并绘制。\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(x, y_cos)\n",
    "plt.title('Cosine')\n",
    "# 显示图表.\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更多内容你可以参考如下网址：(http://matplotlib.org/api/pyplot_api.html#matplotlib.pyplot.subplot)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy.misc import imresize\n",
    "from imageio import imread\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "img = imread('kitten.jpg')\n",
    "img_tinted = img * [1, 0.95, 0.6]\n",
    "\n",
    "# 显示原始图片\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.imshow(img)\n",
    "\n",
    "# 显示着色后的图片\n",
    "plt.subplot(1, 2, 2)\n",
    "\n",
    "plt.imshow(np.uint8(img_tinted))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
